from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

windowId = -1

#MEDIDAS CUERPO
CUERPO_ALTO = 4.0
CUERPO_ANCHO = 2.5
CUERPO_LARGO = 1.0
#MEDIDAS BRAZO
BRAZO_ALTO = 3.5
BRAZO_ANCHO = 1.0
BRAZO_LARGO = 1.0
BRAZO_ANGULO = 30.0

#MEDIDAS PIERNA
PIERNA_ALTO = 4.5
PIERNA_ANCHO = 1.0
PIERNA_LARGO = 1.0
#MEDIDAS CABEZA
CABEZA_RADIO = 1.1

#para la vista en perspectiva
ANGLE_X = 0.0
ANGLE_Y = 0.0
ANGLE_Z = 0.0

def display():

    global BRAZO_ANGULO
    global ANGLE_X
    global ANGLE_Y
    global ANGLE_Z
    
    glClearColor (1.0,1.0,1.0,0.0)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()

    #traslada el dibujo hacia el fondo para que se vea mejor
    glTranslatef(0.0,0.0,-16.0)

    #permite rotar la escena
    glRotatef(ANGLE_X,1.,0.,0.)
    glRotatef(ANGLE_Y,0.,1.,0.)
    glRotatef(ANGLE_Z,0.,0.,1.)
        
    #cuerpo
    glTranslatef(0.0,CUERPO_ALTO/2.0,0.0)
    glPushMatrix()
    glScalef(CUERPO_ANCHO,CUERPO_ALTO,CUERPO_ANCHO)
    glColor3f(0.0,0.3,0.8)#azul
    glutSolidCube(1)
    glPopMatrix()

    #brazo izquierdo
    glPushMatrix()
    glTranslatef(-(CUERPO_ANCHO)/2.0,(CUERPO_ALTO - BRAZO_ALTO)/2.0,0.0)
    #rota el brazo izquierdo 30 grados
    glTranslatef(0.0,BRAZO_ALTO/2.0,0.0)
    glRotatef(-(BRAZO_ANGULO),0.0,0.0,1.0)
    glTranslatef(0.0,-BRAZO_ALTO/2.0,0.0)
    #mantiene la transformacion anterior
    glPushMatrix()
    glScalef(BRAZO_ANCHO,BRAZO_ALTO,BRAZO_LARGO)
    glutSolidCube(1)
    glPopMatrix()
    #mano
    glTranslatef(0.0,-(BRAZO_ALTO+BRAZO_ANCHO)/2.0,0.0)
    glColor3f(1.0,0.6,0.6)
    glScalef(BRAZO_ANCHO,BRAZO_ANCHO,BRAZO_LARGO)
    glutSolidCube(1)
    glPopMatrix()

    #brazo derecho
    glColor3f(0.0,0.3,0.8)
    glPushMatrix()
    glTranslatef((CUERPO_ANCHO)/2.0,(CUERPO_ALTO - BRAZO_ALTO)/2.0,0.0)
    #rota el brazo derecho 30 grados
    glTranslatef(0.0,BRAZO_ALTO/2.0,0.0)
    glRotatef(BRAZO_ANGULO,0.0,0.0,1.0)
    glTranslatef(0.0,-BRAZO_ALTO/2.0,0.0)
    #mantiene la transformacion anterior
    glPushMatrix()
    glScalef(BRAZO_ANCHO,BRAZO_ALTO,BRAZO_LARGO)
    glutSolidCube(1)
    glPopMatrix()
    #mano
    glTranslatef(0.0,-(BRAZO_ALTO+BRAZO_ANCHO)/2.0,0.0)
    glColor3f(1.0,0.6,0.6)
    glScalef(BRAZO_ANCHO,BRAZO_ANCHO,BRAZO_LARGO)
    glutSolidCube(1)
    glPopMatrix()

    #pierna derecha
    glColor3f(0.0,0.3,0.8)
    glPushMatrix()
    glTranslatef(-(CUERPO_ANCHO-PIERNA_ANCHO)/2.0,-(CUERPO_ALTO+PIERNA_ALTO)/2.0,0.0)
    glPushMatrix()
    glScalef(PIERNA_ANCHO,PIERNA_ALTO,PIERNA_LARGO)
    glutSolidCube(1)
    glPopMatrix()
    #pie
    glTranslatef(0.0,-(PIERNA_ALTO+PIERNA_ANCHO)/2.0,PIERNA_LARGO)
    glColor3f(0.3,0.4,0.4)
    glScalef(PIERNA_ANCHO,PIERNA_ANCHO,PIERNA_LARGO*2)
    glutSolidCube(1)
    glPopMatrix()

    #pierna izquierda
    glColor3f(0.0,0.3,0.8)
    glPushMatrix()
    glTranslatef((CUERPO_ANCHO-PIERNA_ANCHO)/2.0,-(CUERPO_ALTO+PIERNA_ALTO)/2.0,0.0)
    glPushMatrix()
    glScalef(PIERNA_ANCHO,PIERNA_ALTO,PIERNA_LARGO)
    glutSolidCube(1)
    glPopMatrix()
    #pie
    glTranslatef(0.0,-(PIERNA_ALTO+PIERNA_ANCHO)/2.0,PIERNA_LARGO)
    glColor3f(0.3,0.4,0.4)
    glScalef(PIERNA_ANCHO,PIERNA_ANCHO,PIERNA_LARGO*2)
    glutSolidCube(1)
    glPopMatrix()

    #cabeza
    glColor3f(1.0,0.6,0.6)
    glPushMatrix()
    glTranslatef(0.0,CUERPO_ALTO/2.0 +CABEZA_RADIO + 0.2,0.0)
    glutSolidSphere(CABEZA_RADIO,10,10)
    glPopMatrix()

    glutSwapBuffers()

def reshape(width, height):
    glViewport(0,0,width,height)

    #para la vista en perspectiva tenga consecuencia en la profundidad
    glDepthFunc(GL_LEQUAL)
    glEnable(GL_DEPTH_TEST)
    glClearDepth(1.0)
    #parametros de la perspectiva
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(60.0,float(height)/float(width) ,1.0,128.0)
    #parametros del objeto
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()

def keyboard(*args):

    global BRAZO_ANGULO
    global ANGLE_X
    global ANGLE_Y
    global ANGLE_Z
    global XYZ
    
    key = args[0]

    #giro de brazos
    if key == '1':
        #no avanza mas de 90 grados
        if BRAZO_ANGULO <= 90:
            BRAZO_ANGULO = (BRAZO_ANGULO + 2.0) % 360
    elif key == '2':
        #no avanza menos de 10 grados
        if BRAZO_ANGULO >= 10:
            BRAZO_ANGULO = (BRAZO_ANGULO - 2.0) % 360
    #rotacion sobre eje x
    elif key == 'q':
        ANGLE_X = (ANGLE_X + 2.0) % 360
    elif key == 'w':
        ANGLE_X = (ANGLE_X - 2.0) % 360
    #rotacion sobre eje y
    elif key == 'a':
        ANGLE_Y = (ANGLE_Y + 2.0) % 360
    elif key == 's':
        ANGLE_Y = (ANGLE_Y - 2.0) % 360
    #rotacion sobre eje z
    elif key == 'z':
        ANGLE_Z = (ANGLE_Z + 2.0) % 360
    elif key == 'x':
        ANGLE_Z = (ANGLE_Z - 2.0) % 360
    elif key == '\033':
        glutDestroyWindow(windowId)
        sys.exit()

    glutPostRedisplay()

    
def main():

    global windowId
    
    glutInit()#CONFIGURACION DE OPENGL
    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE)
    glutInitWindowSize(512,512)
    glutInitWindowPosition(100,100)
    
    windowId = glutCreateWindow("Practica Open GL")

    glutDisplayFunc(display)
    glutReshapeFunc(reshape)
    glutKeyboardFunc(keyboard)

    glutMainLoop()

main()